//2024.03.05 21:18 星期二 阴
// 这个文件 是 根据 给定的 位置信息 进行判定 lightnode 的 具体位置

/**
 * 2024.03.13 15:26 又开始了 又开始了 真的是 狗改不了吃屎  操你妈 的 吕游 纯纯 贱种不是?  俩手 是干嘛的？ 操你大爷！
 */

import { listenCssVar } from '../../../components/aaanewApp/global/cssVarPropsFunc/listenCssVar';
import {
  domTree,
  getNum,
  getReflashImp,
  ObjectOnlyPushSet,
  SetStaticCssTxtFunc,
} from '../../../components/aaanewApp/global/global';
import { lightNode } from '../../lightNode/lightNode';

let magLight = SetStaticCssTxtFunc('magenet_lightNode');

const splitstr = '_';

/**
 * 默认 lightNode 的元素 宽度
 */
// const defaultWeight = 2;

/**
 * 方位
 */
const dirction = 'dirction';

const width = 'width';

const height = 'height';

const top = 'top';

const left = 'left';

/**
 * 方位 偏移量限制 区域 0 最小 0+1 最大
 */
const dircPoiReflect = {
  top: [left, width],
  right: [top, height],
  bottom: [left, width],
  left: [top, height],
};

const dircPoiSupReflect = {
  top: [[top], -1, height],
  right: [[left, width]],
  bottom: [[top, height]],
  left: [[left], -1, width],
};

// const dirclightNodeSupPoiReflect = {
//   top: [left, top, -1, height],
//   right: [top, left, 0, width],
//   bottom: [left, top, 0, height],
//   left: [top, left, -1, width],
// };

let lightNodeImp = { data: [] };

let lightNodeObj = {
  /**
   * 上一个 使用的 lightNode 元素
   */
  lastNode: undefined,

  /**
   * 当前使用的 lightNode 元素
   */
  node: undefined,

  /**
   * 元素 top 位置  已经 计算好的
   */
  top: undefined,

  /**
   * 元素 left 位置  已经 计算好的
   */
  left: undefined,

  /**
   * 元素 lightNode 当前 是否有 更替 非 当前更替 为 false
   */
  hasChangedNode: false,

  /**
   * 使用的 lightNode Css [单个 或 数组]
   */
  usedLightCss: [],

  /**
   * 使用 用户指定 元素 为 lightNode 移除 上一个元素的 相关 Css 变量 并 添加到 用户指定元素中
   */
  useLightEl: undefined,

  /**
   * 添加 用户 的 Css 变量 并 记录相关信息
   */
  addLightCss: undefined,

  /**
   * 移除 用户 的 Css [单个 或 数组]
   */
  removeLightCss: undefined,

  /**
   * 用户 自定义函数 绑定 当前 lightNode 对象
   */
  callFunc: undefined,
};

/**
 * 最后一次处理的 方位
 */
let lastDir;

/**
 * 最后一次处理的 元素ID
 */
let lastID;

/**
 * 是否需要 更新 lightNode 信息
 */
let renewLightNode = false;

/**
 * 监听 lightNode 的 cssVar
 */
let cssVarListen;

/**
 * 根据信息集 创建 默认的 lightNode
 * @param {Object} overInfo 元素 over 信息集
 */
function settleLightNode(overInfo) {
  //   console.log(overInfo);

  // 更新 数据
  renewInfos(overInfo);

  //   解析 lightNode 的 top left 位置
  let deployedInfo = deploysis(overInfo);

  settleLightNodeTopLeft(deployedInfo);
  //   console.log(lightNodeImp);

  return lightNodeObj;
}

/**
 * settleLightNode ~~分支
 *
 * 更新数据 部分
 * @param {Object} overInfo 元素 over 信息集
 */
function renewInfos(overInfo) {
  //   初始 和 非相同 指定 Element ID 的 元素
  //   -- 创建 lightNode 添加到 lightNodeImp
  if (lastID == undefined || lastID != overInfo['elID']) {
    // console.log('新添加 lightNode 节点');

    // 设置 最后一次 处理的元素
    lastID = overInfo['elID'];

    lightNodeObj = lightNode();

    let hasValue = ObjectOnlyPushSet(
      lightNodeImp,
      overInfo['elID'],
      lightNodeObj
    );
    if (!hasValue) {
      lightNodeImp[overInfo['elID']] = lightNodeObj;
    }

    // 启用 更新 lightNode 信息
    renewLightNode = true;
  }

  //   初始 和 非相同 方位 的 数据  需要 热更新 LightNode
  if (lastDir == undefined || lastDir != overInfo[dirction]) {
    // 设置 最后一次 处理的 方位
    lastDir = overInfo[dirction];

    // 启用 更新 lightNode 信息
    renewLightNode = true;
  }

  //   热更新 LightNode
  if (renewLightNode) {
    // console.log('更新 lightNode');
    lightNodeObj['hasChangedNode'] = true;

    lightNodeObj['lastNode'] = lightNodeObj['node'];

    lightNodeObj['node'] = createLightNode(overInfo);

    cssVarListen = listenCssVar(lightNodeObj['node']);

    // 关闭 更新 lightNode 信息
    renewLightNode = false;
  } else if (lightNodeObj['hasChangedNode']) {
    lightNodeObj['hasChangedNode'] = false;
  }
}

/**
 * 创建 lightnode  元素
 * @param {Object} nodeInfo lightNode 位置 大小 信息
 */
function createLightNode(nodeInfo) {
  //   console.log(nodeInfo);

  let lightNodeTree = {
    queue: ['a'],
    a: {
      tag: 'div',
      props: ['classList', 'id', 'style'],

      style: `width:${nodeInfo[width]}px;height:${nodeInfo[height]}px;--top:${nodeInfo[top]}px;--left:${nodeInfo[left]}px;`,

      classList: [
        'lightNode',
        'lightDefaultBgc' + splitstr + nodeInfo[dirction],
      ],
      id: nodeInfo['elID'] + splitstr + 'lightNode',
    },
  };

  let lightNode = domTree(undefined, lightNodeTree);

  return lightNode;
}

/**
 * 根据 over 信息集 返回 元素 实际 吸附位置 返回 {top,left}
 * @param {Object} overInfo 元素 over 信息集
 * @returns
 */
function deploysis(overInfo) {
  //   console.log(overInfo);
  let limitElpo = { top: undefined, left: undefined };

  let dir = overInfo['dirction'];

  //   [left,top] limit  区域限制
  let EldirPoi = dircPoiReflect[dir][0];
  let EldirPoi1 = dircPoiReflect[dir][1];

  //   补充 方位
  let supDir = dircPoiSupReflect[dir][0][0];
  //   补充 方位 数值
  let supNum = 0;

  limitElpo[EldirPoi] = overInfo['elpo'][EldirPoi];
  if (limitElpo[EldirPoi] < overInfo['magnetElpo'][EldirPoi]) {
    limitElpo[EldirPoi] = overInfo['magnetElpo'][EldirPoi];
  }

  let maxLimit =
    overInfo['magnetElpo'][EldirPoi] +
    overInfo['magnetElpo'][EldirPoi1] -
    overInfo['elpo'][EldirPoi1];
  if (limitElpo[EldirPoi] > maxLimit) {
    limitElpo[EldirPoi] = maxLimit;
  }

  //   确定 主体位置 magnetElpo
  for (let i = 0; i < dircPoiSupReflect[dir][0].length; i++) {
    supNum += overInfo['magnetElpo'][dircPoiSupReflect[dir][0][i]];
  }

  //   偏移 elpo 元素位置
  if (dircPoiSupReflect[dir][1] != undefined) {
    supNum +=
      dircPoiSupReflect[dir][1] * overInfo['elpo'][dircPoiSupReflect[dir][2]];
  }

  limitElpo[supDir] = supNum;

  limitElpo[dirction] = dir;
  limitElpo[width] = overInfo['elpo'][width];
  limitElpo[height] = overInfo['elpo'][height];
  console.log(limitElpo);
  return limitElpo;
}

/**
 *
 * @param {Object} deployedInfo 解析后的 数据信息
 */
function settleLightNodeTopLeft(deployedInfo) {
  //   let dir = deployedInfo[dirction];
  //   let lnReflect = dirclightNodeSupPoiReflect[dir];
  //   console.log(deployedInfo);
  cssVarListen.setCssVar('--top', getNum(deployedInfo[top]) + 'px');
  cssVarListen.setCssVar('--left', getNum(deployedInfo[left]) + 'px');

  //   let a1 = deployedInfo[lnReflect[0]];
  //   let a2 =
  //     deployedInfo[lnReflect[1]] + lnReflect[2] * deployedInfo[lnReflect[3]];
  //   cssVarListen.setCssVar(`--${lnReflect[0]}`, deployedInfo[lnReflect[0]]);
  //   cssVarListen.setCssVar(
  //     `--${lnReflect[1]}`,
  //     deployedInfo[lnReflect[1]] + lnReflect[2] * deployedInfo[lnReflect[3]]
  //   );
  //   console.log(deployedInfo[top], deployedInfo[left]);
}

/**
 * 获取 (更新) lightNode 冲积平原
 * @param {Boolean} renew 是否更新 lightNode 冲积平原
 */
function getLightNodeImp(renew) {
  return getReflashImp(lightNodeImp, renew);
}

function lightNodeStaticCss() {
  magLight(
    'lightNode',
    `.lightNode {
        position: absolute;
        top: var(--top);
        left: var(--left);

        width: 50px;
        height: 90px;
        background-color: #564397;
      }`
  );
}
lightNodeStaticCss();
export { settleLightNode, getLightNodeImp };
